# 作业：
# 1、写函数,将传入的列表或元祖对象的奇数位索引对应的元素
"""
list1 = [12,55,88,99,10,20] # 55 99 20
list2 = [88,99,102,33,66,99]
result = []
for i in range(len(list1)):
    if i%2!=0:
        result.append(list1[i])
print(result)

result1 = []
for i in range(len(list2)):
    if i%2!=0:
        result1.append(list2[i])
print(result1)
"""
import random

"""
def 王长帅(参数):
    result = []
    for i in range(len(参数)):
        if i % 2 != 0:
            result.append(参数[i])
    return result
print(王长帅([22, 11, 44, 55, 88, 99]))
print(王长帅([88,99,102,33,66,99]))
"""
# 2、写函数,判断用户传入的对象(string,list,tuple)长度是否大于5
def istype(con):
    if type(con) == str and len(con) > 5:
        print("传入的字符串长度大于5")
    elif type(con) == str and len(con) < 5:
        print("传入的字符串长度小于5")
    elif type(con) == list and len(con) > 5:
        print("传入的列表长度大于5")
    elif type(con) == list and len(con) < 5:
        print("传入的列表长度小于5")
    elif type(con) == tuple and len(con) > 5:
        print("传入的元组长度大于5")
    elif type(con) == tuple and len(con) < 5:
        print("传入的元组长度小于5")
# istype([123,123,123,123,123,123])
# istype((123,123,123,123,123,123))
# istype("123,123,123,123,123,123")
"""
con = [123,123,123,123,123,123]
if type(con) == str and len(con) > 5:
    print("传入的字符串长度大于5")
elif type(con) == str and len(con) < 5:
    print("传入的字符串长度小于5")
elif type(con) == list and len(con) >5:
    print("传入的列表长度大于5")
elif type(con) == list and len(con) <5:
    print("传入的列表长度小于5")
elif type(con) == tuple and len(con) > 5:
    print("传入的元组长度大于5")
elif type(con) == tuple and len(con) < 5:
    print("传入的元组长度小于5")
"""
# 3、写函数,计算传入的string中,数字,字母,空格以及其它内容的个数,并返回结果
"""
def conunt(result):
    num = 0
    space = 0
    str1 = 0
    other = 0
    for i in result:
        if i in "0123456789":
            num+=1
        elif i in " ":
            space+=1
        elif (i >= "a" and i <="z") or (i >='A' and i<='Z'):
            str1+=1
        else:
            other+=1
    return f"字母有{str1},数字有{num}，空格有{space},其他有{other}"
print(conunt("asd 123 !@#$%^&"))
"""
# 请你写个函数，返回1-100之间的所有偶数
"""
def return_oushu():
    for i in range(1,101):
        if i %2==0:
            print(i)
"""

# 4、写函数,接收两个数字参数,返回较大的那个数字
"""
def max_num(a,b):
    if a > b:
        return a
    else:
        return b
"""
"""
a = int(input("请输入数字a"))
b = int(input("请输入数字b"))
if a > b:
    print(a)
else:
    print(b)
"""

# 5、编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
def cacluate1(*a):
    return a
# 5、编写一个函数cacluate, 可以接收任意多个数,返回的是一个列表.
"""
def cacluate(*a):
    return list(a)
print(cacluate(12,12,12,45,12,14512,3165,132,1,5630,561,32,1,561,3))
"""

# 6、编写一个函数, 接收字符串参数, 返回一个元组,元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
"""
result = input("请输入字符串参数")
capitaliza_count = 0
small_letter_count = 0
for i in result:
    if i >="a" and i <="z":
        small_letter_count+=1
    elif i >="A" and i <="Z":
        capitaliza_count+=1
tuple1 = (capitaliza_count,small_letter_count)
print(tuple1)

def str_count(result):
    capitaliza_count = 0
    small_letter_count = 0
    for i in result:
        if i >= "a" and i <= "z":
            small_letter_count += 1
        elif i >= "A" and i <= "Z":
            capitaliza_count += 1
    return capitaliza_count,small_letter_count
"""
# 7、编写函数, 接收一个列表(包含30个1~100之间的随机整形数)和一个整形数k, 返回一个新列表.
# 函数需求:
# 将列表下标k之前对应(不包含k)的元素逆序;
# 将下标k及之后的元素逆序;
def new_list(k:int): #  list 表明传入的对象是整数类型
    result = [] #收集列表
    for i in range(30):
        result.append(random.randint(1,100))
    print(result)
    list1 = result[:k][::-1]
    list2 = result[k:][::-1]
    return list1+list2
# 8、编写函数，从键盘输入参数x和n，计算并显示形如x+xx +xxx + xxxx + xxxxx+xxx…xxx+ 的表达式前n项的值
def result_num(x,n):
    a = x  # 个位数
    result = 0
    for i in range(n):
        result += x
        x = x * 10 + a
    return result
# 9、写函数,函数接收的4个参数分别是:姓名,性别(默认为男),年龄,地址
def fuc_info(name,age,address,sex="男"):
    return f"学生的姓名是：{name},学生的年龄是：{age}，学生的地址是{address}，学生的性别是：{sex}"
# 10、写函数,接收n个数字,返回这些数字的和(动态传参)
def num_sum(*n):
    result = 0
    for i in n:
        result+=i
    return result

# 11、在实参中传入多个可迭代对象(要有string,list,tuple,set,dict),将每个对象的每个元素都加到args或kwargs里
def container(*args,**kwargs):
    print(f"不定长参数{args}")
    print(f"关键字不定长参数{kwargs}")

# container(12,33,"王长帅不是很帅",姓名="王长帅")
# 12、写函数,把传过来的列表中的每一个元素都用"_"拼接,并返回
def montage_list(list1:list):
    str1 = ""
    for i in list1:
        str1 += str(i) + "_"
    return str1
# print(montage_list([12, 33, 55, 66]))

# 13、写函数,传入一个数字,返回这个数的阶乘。示例：1x2x3....
def factorial(a):
    result = 1
    for i in range(1,a+1):
        result = result*i
    return result

# 14、写函数,返回一个扑克牌列表,里面有52项,每一项都是一个tuple
def Poker_list():
    result = []
    Decor = ['梅花','梅桃','红片','红桃']
    brand = [i for i in range(2,11)] # 没特殊牌
    special_brand = ['J','Q','K','A']
    brand = brand + pecial_brand
    for i in Decor:
        for j in brand:
            result.append((i,j))
    return result
# print(Poker_list())
# 15、编写函数，求1+2+3+…N的和
def gentle(n):
    result = 0
    for i in range(1,n+1):
        result+=i
    return result

# 16、编写一个函数，求多个数中的最大值
def max_num_plus(*num):
    a = list(num)
    a.sort(reverse=True)
    return a[0]

# print(max_num_plus(12,55,88,99,101,99988,77))
# 17、编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
def new_str(str1):
    result = ""
    for i in str1:
        if (i >='a' and i <= 'z') or (i >='A' and i <='Z'):
            result+=i
    return result
# print(new_str("asd12356123asdasqwdsa3d21as23d156as1d231q56wd"))
# 18、写一个函数，求多个数的平均值
def avg_num(*num):
    return sum(num) / len(num)
# 19、写一个自己的len函数，统计指定序列中元素的个数
def len_container(container):
    result = 0
    for i in container:
        result+=1
    return result # 长度
# print(len_container("asd123456"))
# 20、找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
def result_list(container):
    list1 = []
    for i in range(len(container)):
        if i%2!=0:
            list1.append(container[i])
    return list1
# 21、水仙花数：个位、十位、百位的立方加在一起等于数的本身，传入这个数判断是否是水仙花数
def daffodil(num):
    bai = num // 100 # 百
    shi = (num%100) //10 # 十
    ge = (num%100)%10
    if bai**3 + shi **3 +ge**3 == num:
        print("是水仙花数")
    else:
        print("不是水仙花数")
def daffodil_count():
    count = 0
    for i in range(100,1001):
        bai = i // 100  # 百
        shi = (i % 100) // 10  # 十
        ge = (i % 100) % 10
        if bai ** 3 + shi ** 3 + ge ** 3 == i:
            print(bai,shi,ge)
            count+=1
    return count
# print(daffodil_count())
# 22、 定义函数，有一个形参，传入的是列表，数组大小不超过 100个，
# 数组中的每个元素值不允许超过 100，但是可以等于100，
# 如果列表大小超过了100个截取到第100个为止，要求返回的列表格式：
# 删除所有重复元素，使得每个元素只出现一次
# 按照数字的大小，由高到低排序返回
def new_list1(list1:list):
    result = []
    if len(list1) > 100:
        list1 = list1[:100]
        for i in list1:
            if i > 100:
                continue
            result.append(i)
        list1 = list(set(result))
        list1.sort(reverse=True)
        return list1
    else:
        for i in list1:
            if i > 100:
                continue
            result.append(i)
        list1 = list(set(result))
        list1.sort(reverse=True)
        return list1
test_list = [101, 22, 55, 88, 99,
                 109, 22, 55, 88, 99, 98, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109, 22, 55, 88, 99, 109]

# print(new_list1(test_list))

# 23、定义函数 getLength，打印用户传入的容器类型和数据长度
def getLength(container):
    if type(container) == str:
        return f"是字符串,长度为{len(container)}"
    elif type(container) == list:
        return f"是列表,长度为{len(container)}"
    elif type(container) == tuple:
        return f"是元组,长度为{len(container)}"
    elif type(container) == set:
        return f"是集合,长度为{len(container)}"
    elif type(container) == dict:
        return f"是字典,长度为{len(container)}"

# 24、定义函数 generateNum( )
def generateNum():
    print("我叫王长帅")

# 25、定义函数 moreThan(num)，判断输入的数字是否大于1500
def moreThan(num):
    if num > 1500:
        print("大于1500")
    elif num == 1500:
        print("等于1500")
    else:
        print("小于1500")

# 26、定义函数，有两个形参，第一个形参到第二个形参的范围，所有平方数之和
def Square_number(a,b):
    result = 0
    for i in range(a,b+1):
        result+=i**2
    return result


# print(Square_number(1, 5)) # 1=1 2=4 3=9 4=16 5=25

# 27、写函数，检查传入字典的每一个value长度，如果大于2，
# 那么仅保留前两个长度的内容， 并将新内容返回给调用者
def new_dict(dict1:dict):
    for key,value in dict1.items():
        if len(value) > 2:
            dict1[key] = value[:2]
    return dict1
# print(new_dict({"姓名":"王帅不是很帅的长帅长帅"}))

#  28、写函数，判断用户传入的对象（字符串、列表、元组）的元素是否为空
def determine(container):
    if type(container) == str and len(container) !=0:
        return f"是字符串,长度为{len(container)}"
    else:
        return f"是字符串,为空"
    #"不改了都一样"
    # elif type(container) == list:
    #     return f"是列表,长度为{len(container)}"
    # elif type(container) == tuple:
    #     return f"是元组,长度为{len(container)}"
    # elif type(container) == set:
    #     return f"是集合,长度为{len(container)}"
    # elif type(container) == dict:
    #     return f"是字典,长度为{len(container)}"

# 29、编写自定义函数，完成一个简单的减法运算函数
def calculator(a,b,math):
    if math == "-":
        return a-b
    elif math == "*":
        return a*b
    elif math == "/":
        return a/b
    elif math == "//":
        return a//b

# 30、编写自定义函数，可以输出自己的名字即可。
# 31、编写自定义函数：剪刀石头布
# 游戏开始，初始状态下用户和电脑都有 100 分，赢一局+10 分，输一局-10 分。

#  当用户为 0 分时，游戏结束，提示游戏结束，比赛输了

# 当用户为 200 分时，游戏结束，提示游戏结束，赢得比赛、每轮比赛都输出当前的分数

# 1 代表剪刀 2 代表石头 3 代表布
def game():
    user = 100
    computer = 100
    while True:
        user_attack = int(input("请输入石头、剪刀、布头（1，2，3）"))
        computer_attack = random.randint(1,3) # 电脑出招
        if user_attack == 1 and computer_attack == 1:
            print("平局，谁也不扣分！")
            print(f"玩家还有{user}分,电脑还有{computer}分！")
        elif user_attack ==1 and computer_attack == 2:
            user+=10
            computer-=10
            print(f"玩家胜！玩家还有{user}分,电脑还有{computer}分！")
        elif user_attack ==1 and computer_attack == 3:
            user-=10
            computer+=10
            print(f"电脑胜！玩家还有{user}分,电脑还有{computer}分！")
        elif user_attack ==2 and computer_attack == 1:
            user-=10
            computer+=10
            print(f"电脑胜！玩家还有{user}分,电脑还有{computer}分！")
        elif user_attack ==2 and computer_attack == 2:
            print("平局，谁也不扣分！")
            print(f"玩家还有{user}分,电脑还有{computer}分！")
        elif user_attack ==2 and computer_attack == 3:
            user += 10
            computer -= 10
            print(f"玩家胜！玩家还有{user}分,电脑还有{computer}分！")
        elif user_attack ==3 and computer_attack == 1:
            user += 10
            computer -= 10
            print(f"玩家胜！玩家还有{user}分,电脑还有{computer}分！")
        elif user_attack ==3 and computer_attack == 2:
            user -= 10
            computer += 10
            print(f"电脑胜！玩家还有{user}分,电脑还有{computer}分！")
        elif user_attack ==3 and computer_attack == 3:
            print("平局，谁也不扣分！")
            print(f"玩家还有{user}分,电脑还有{computer}分！")
        else:
            print("出招错误！请重新出招！")
        if computer == 0:
            print("玩家胜！")
        if user == 0:
            print("电脑胜！")

# game()
# 32、编写一个函数，接受一个字符串作为参数，并返回该字符串的逆序字符串
def new_str1(str1):
    return str1[::-1]



# 33、编写一个函数，接受一个数字列表作为参数，并返回其中所有偶数的列表
# 34、编写一个函数，接受一个字符串列表作为参数，并返回其中最长的字符串。
# def max_str(list1:list):
#     dict1 = {}
#     for i in list1:
#         dict1[i] = len(i)
#     values = max(dict1.values())
#     for key,value in dict1.items():
#         if value == values:
#             return key
# print(max_str(['asd', 'asdsad', 'qwdasdsadsa']))


def long_str(str1):
    long_result  = str1[0]
    for i in str1:
        if len(i) > len(long_result):
            long_result = i
    return long_result
# print(long_str(['asd', 'asdsad', 'qwdasdsadsa']))



# 35、编写一个函数，接受一个数字列表作为参数，并返回其中所有数字的平方的总和


# 36、编写一个函数，接受多个字符串作为参数，并返回其中所有单词的首字母的大写形式
def capitalization_str(*str1):
    str2 = ""
    for i in range(len(str1)): # 0 1 2 3 str1[0]  str2 += Asd Qwe Poi
        str2 += str(str1[i]).capitalize() + " "
    return str2
print(capitalization_str("asd", "qwe", "poi"))

# 37、编写一个函数，接受两个列表作为参数，并返回两个列表的交集
# 举例：
# list1 = [100,200,300,454]
# list2 = [454,789,125,46]
# 返回：[454]
def list_intersection(list1,list2):
    result = []
    for i in list1:
        if i in list2:
            result.append(i)
    return result
# print(list_intersection([100,200,300,454],[454,789,125,46]))

def list_intersection1(list1,list2):
    set_list1 = set(list1)
    set_list2 = set(list2)
    return list(set_list1 & set_list2)


# print(list_intersection([100, 200, 300, 454], [454, 789, 125, 46]))

#  38、定义一个学生注册函数enroll()，打印学生姓名，性别，年龄，城市， 使用默认参数降低调用函数的复杂度
def enroll(name,sex,age,city):
    print(f"我叫{name}，我是{sex}性,我今年{age}岁，我来自{city}")
name=input("请输入姓名")
sex=input("请输入性别")
age=input("请输入年龄")
city=input("请输入城市")

enroll(name,sex,age,city)

